<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
        <head><title>trait Suite in org.scalatest</title>
        <meta http-equiv="content-type" content="text/html; charset=UTF8"></meta><meta content="scaladoc (version 2.7.2.final)" name="generator"></meta><link href="../../style.css" type="text/css" rel="stylesheet"></link><script type="text/javascript" src="../../script.js"></script>
        </head>
        <body onload="init()">
        <table summary="" class="navigation">
        <tr>
          <td class="navigation-links" valign="top">
            <!-- <table><tr></tr></table> -->
          </td>
          <td align="right" valign="top" style="white-space:nowrap;" rowspan="2">
            <div class="doctitle-larger">ScalaTest 0.9.4</div>
          </td>
        </tr>
        <tr><td></td></tr>
      </table>
        
      <div class="entity">
        <a href="../../org/scalatest$package.html" target="_self">org.scalatest</a>
        <br></br>
        <span class="entity">trait  Suite</span>
      </div><hr></hr>
      <div class="source">
        [source: <a href="" class="org/scalatest/Suite"><code>org/scalatest/Suite.scala</code></a>]
      </div><hr></hr>
      <a name="Suite"></a><dl>
      <dt>
        @<a href="" target="contentFrame" class="scala/serializable">scala.serializable</a><br></br>
        <code></code>
        <code>trait</code>
        <em>Suite</em>
      </dt>
      <dd><code> extends </code><a href="../../org/scalatest/Assertions.html" target="_self">Assertions</a><code> with </code><a href="../../org/scalatest/ExecuteAndRun.html" target="_self">ExecuteAndRun</a></dd>
    </dl>
      <dl><dd><p>
 A suite of tests. A <code>Suite</code> instance encapsulates a conceptual
 suite (<em>i.e.</em>, a collection) of tests. This trait defines a default way to create
 and execute tests, which involves writing <em>test methods</em>. This approach will likely suffice
 in the vast majority of applications, but if desired, subtypes can override certain methods
 to define other ways to create and execute tests.
 </p>

 <p>
 The easiest way to use this trait is to use its default approach: Simply create classes that
 extend <code>Suite</code> and define test methods. Test methods have names of the form <code>testX</code>, 
 where <code>X</code> is some unique, hopefully meaningful, string. A test method must be public and
 can have any result type, but the most common result type is <code>Unit</code>. Here's an example:
 </p>

 <pre>
 import org.scalatest.Suite

 class MySuite extends Suite {

   def testAddition() {
     val sum = 1 + 1
     assert(sum === 2)
     assert(sum + 2 === 4)
   }

   def testSubtraction() {
     val diff = 4 - 1
     assert(diff === 3)
     assert(diff - 2 === 1)
   }
 }
 </pre>

 <p>
 You run a <code>Suite</code> by invoking on it one of three overloaded <code>execute</code>
 methods. Two of these <code>execute</code> methods, which print test results to the
 standard output, are intended to serve as a
 convenient way to run tests from within the Scala interpreter. For example,
 to run <code>MySuite</code> from within the Scala interpreter, you could write:
 </p>

 <pre>
 scala> (new MySuite).execute()
 </pre>

 <p>
 And you would see:
 </p>

 <pre>
 Test Starting - MySuite.testAddition
 Test Succeeded - MySuite.testAddition
 Test Starting - MySuite.testSubtraction
 Test Succeeded - MySuite.testSubtraction
 </pre>

 <p>
 Or, to run just the <code>testAddition</code> method, you could write:
 </p>

 <pre>
 scala> (new MySuite).execute("testAddition")
 </pre>

 <p>
 And you would see:
 </p>

 <pre>
 Test Starting - MySuite.testAddition
 Test Succeeded - MySuite.testAddition
 </pre>

 <p>
 The third overloaded <code>execute</code> method takes seven parameters, so it is a bit unwieldy to invoke from
 within the Scala interpreter. Instead, this <code>execute</code> method is intended to be invoked indirectly by a test runner, such
 as <code>org.scalatest.tools.Runner</code> or an IDE. See the <a href="tools/Runner$object.html">documentation for <code>Runner</code></a> for more detail.
 </p>

 <p>
 <strong>Assertions and ===</strong>
 </p>

 <p>
 Inside test methods, you can write assertions by invoking <code>assert</code> and passing in a <code>Boolean</code> expression,
 such as:
 </p>

 <pre>
 val left = 2
 val right = 1
 assert(left == right)
 </pre>

 <p>
 If the passed expression is <code>true</code>, <code>assert</code> will return normally. If <code>false</code>,
 <code>assert</code> will complete abruptly with an <code>AssertionError</code>. This exception is usually not caught
 by the test method, which means the test method itself will complete abruptly by throwing the <code>AssertionError</code>. Any
 test method that completes abruptly with an <code>AssertionError</code> or any <code>Exception</code> is considered a failed
 test. A test method that returns normally is considered a successful test.
 </p>

 <p>
 If you pass a <code>Boolean</code> expression to <code>assert</code>, a failed assertion will be reported, but without
 reporting the left and right values. You can alternatively encode these values in a <code>String</code> passed as
 a second argument to <code>assert</code>, as in:
 </p>
 
 <pre>
 val left = 2
 val right = 1
 assert(left == right, left + " did not equal " + right)
 </pre>

 <p>
 Using this form of <code>assert</code>, the failure report will include the left and right values, thereby
 helping you debug the problem. However, <code>Suite</code> provides the <code>===</code> operator to make this easier.
 You use it like this:
 </p>

 <pre>
 val left = 2
 val right = 1
 assert(left === right)
 </pre>

 <p>
 Because you use <code>===</code> here instead of <code>==</code>, the failure report will include the left
 and right values. For example, the detail message in the thrown <code>AssertionErrorm</code> from the <code>assert</code>
 shown previously will include, "2 did not equal 1".
 From this message you will know that the operand on the left had the value 2, and the operand on the right had the value 1.
 </p>

 <p>
 If you're familiar with JUnit, you would use <code>===</code>
 in a ScalaTest <code>Suite</code> where you'd use <code>assertEquals</code> in a JUnit <code>TestCase</code>.
 The <code>===</code> operator is made possible by an implicit conversion from <code>Any</code>
 to <code>Equalizer</code>. If you're curious to understand the mechanics, see the <a href="Suite.Equalizer.html">documentation for
 <code>Equalizer</code></a> and <code>Suite</code>'s <code>convertToEqualizer</code> method.
 </p>

 <p>
 <strong>Expected results</strong>
 </p>

 Although <code>===</code> provides a natural, readable extension to Scala's <code>assert</code> mechanism,
 as the operands become lengthy, the code becomes less readable. In addition, the <code>===</code> comparison
 doesn't distinguish between actual and expected values. The operands are just called <code>left</code> and <code>right</code>,
 because if one were named <code>expected</code> and the other <code>actual</code>, it would be difficult for people to
 remember which was which. To help with these limitations of assertions, <code>Suite</code> includes a method called <code>expect</code> that
 can be used as an alternative to <code>assert</code> with <code>===</code>. To use <code>expect</code>, you place
 the expected value in parentheses after <code>expect</code>, and follow that by code contained inside
 curly braces that results in a value that you expect should equal the expected value. For example:

 <pre>
 val a = 5
 val b = 2
 expect(2) {
   a - b
 }
 </pre>

 <p>
 In this case, the expected value is <code>2</code>, and the code being tested is <code>a - b</code>. This expectation will fail, and
 the detail message in the <code>AssertionError</code> will read, "Expected 2, but got 3."
 </p>

 <p>
 <strong>Intercepted exceptions</strong>
 </p>

 <p>
 Sometimes you need to test whether a method throws an expected exception under certain circumstances, such
 as when invalid arguments are passed to the method. You can do this in the JUnit style, like this:
 </p>

 <pre>
 val s = "hi"
 try {
   s.charAt(-1)
   fail()
 }
 catch {
   case e: IndexOutOfBoundsException => // Expected, so continue
 }
 </pre>

 <p>
 If <code>charAt</code> throws <code>IndexOutOfBoundsException</code> as left, control will transfer
 to the catch case, which does nothing. If, however, <code>charAt</code> fails to throw an exception,
 the next statement, <code>fail()</code>, will be executed. The <code>fail</code> method always completes abruptly with
 an <code>AssertionError</code>, thereby signaling a failed test.
 </p>

 <p>
 To make this common use case easier to express and read, <code>Suite</code> provides an <code>intercept</code>
 method. You use it like this:
 </p>

 <pre>
 val s = "hi"
 intercept(classOf[IndexOutOfBoundsException]) {
   s.charAt(-1)
 }
 </pre>

 <p>
 This code behaves much like the previous example. If <code>charAt</code> throws an instance of <code>IndexOutOfBoundsException</code>,
 <code>intercept</code> will return that exception. But if <code>charAt</code> completes normally, or throws a different
 exception, <code>intercept</code> will complete abruptly with an <code>AssertionError</code>. <code>intercept</code> returns the
 caught exception so that you can inspect it further if you wish, for example, to ensure that data contained inside
 the exception has the expected values.
 </p>

 <p>
 <strong>Using other assertions</strong>
 </p>

 <p>
 If you are comfortable with assertion mechanisms from other test frameworks, chances
 are you can use them with ScalaTest. Any assertion mechanism that indicates a failure with an exception
 can be used as is with ScalaTest. For example, to use the <code>assertEquals</code>
 methods provided by JUnit or TestNG, simply import them and use them. (You will of course need
 to include the relevant JAR file for the framework whose assertions you want to use on either the
 classpath or runpath when you run your tests.) Here's an example in which JUnit's assertions are
 imported, then used within a ScalaTest suite:
 </p>

 <pre>
 import org.scalatest.Suite
 import org.junit.Assert._

 class MySuite extends Suite {

   def testAddition() {
     val sum = 1 + 1
     assertEquals(2, sum)
     assertEquals(4, sum + 2)
   }

   def testSubtraction() {
     val diff = 4 - 1
     assertEquals(3, diff)
     assertEquals(1, diff - 2)
   }
 }
 </pre>

 <p>
 Alternatively, you might prefer the more English-like look and more detailed error messages 
 provided by <a href="http://code.google.com/p/hamcrest/"><em>Hamcrest matchers</em></a>. As with
 JUnit or TestNG assertions, you can use these in ScalaTest suites simply by importing them and
 using them. Here's an example:
 </p>
 
 <pre>
 import org.scalatest.Suite
 import org.hamcrest.Matchers._
 import org.hamcrest.MatcherAssert.assertThat

 class MySuite extends Suite {

   def testAddition() {
     val sum = 1 + 1
     assertThat(sum, is(2))
     assertThat(sum + 2, is(4))
   }

   def testSubtraction() {
     val diff = 4 - 1
     assertThat(diff, is(3))
     assertThat(diff - 2, is(1))
   }
 }
 </pre>
 
 <p>
 You will, of course, need to include the Hamcrest jar file
 in your class or run path when you run your ScalaTest suites that use Hamcrest matchers.
 </p>
 
 <p>
 You may instead prefer to use the matchers provided by the <a href="http://code.google.com/p/specs/">specs framework</a>, which take greater
 advantage of Scala than Hamcrest matchers, since specs is written in Scala. (The Hamcrest library is written in Java.)
 To use specs matchers, simply mix in trait <code>org.specs.SpecsMatchers</code> into your ScalaTest suite. Here's an example:
 </p>
 
 <pre>
 import org.scalatest.Suite
 import org.specs.SpecsMatchers

 class MySuite extends Suite with SpecsMatchers {

   def testAddition() {
     val sum = 1 + 1
     sum mustBe 2
     sum + 2 mustBe 4
   }

   def testSubtraction() {
     val diff = 4 - 1
     diff mustBe 3
     diff - 2 mustBe 1
   }
 }
 </pre>
 
 <p>
 The <code>SpecsMatchers</code> trait was added to specs version 1.2.8. You will, of course, need to include the specs jar file
 in your class or run path when you run your ScalaTest suites that use specs matchers.
 </p>
 
 <p>
 <strong>Nested suites</strong>
 </p>

 <p>
 A <code>Suite</code> can refer to a collection of other <code>Suite</code>s,
 which are called <em>nested</em> <code>Suite</code>s. Those nested  <code>Suite</code>s can in turn have
 their own nested  <code>Suite</code>s, and so on. Large test suites can be organized, therefore, as a tree of
 nested <code>Suite</code>s.
 This trait's <code>execute</code> method, in addition to invoking its
 test methods, invokes <code>execute</code> on each of its nested <code>Suite</code>s.
 </p>

 <p>
 A <code>List</code> of a <code>Suite</code>'s nested <code>Suite</code>s can be obtained by invoking its
 <code>nestedSuites</code> method. If you wish to create a <code>Suite</code> that serves as a
 container for nested <code>Suite</code>s, whether or not it has test methods of its own, simply override <code>nestedSuites</code>
 to return a <code>List</code> of the nested <code>Suite</code>s. Because this is a common use case, ScalaTest provides
 a convenience <code>SuperSuite</code> class, which takes a <code>List</code> of nested <code>Suite</code>s as a constructor
 parameter. Here's an example:
 </p>

 <pre>
 import org.scalatet.Suite

 class ASuite extends Suite
 class BSuite extends Suite
 class CSuite extends Suite

 class AlphabetSuite extends SuperSuite(
   List(
     new ASuite,
     new BSuite,
     new CSuite
   )
 )
 </pre>

 <p>
 If you now run <code>AlphabetSuite</code>, for example from the interpreter:
 </p>

 <pre>
 scala> (new AlphabetSuite).execute()
 </pre>

 <p>
 You will see reports printed to the standard output that indicate nested
 suites&#8212;<code>ASuite</code>, <code>BSuite</code>, and
 <code>CSuite</code>&#8212;were run.
 </p>

 <p>
 Note that <code>Runner</code> can discover <code>Suite</code>s automatically, so you need not
 necessarily specify <code>SuperSuite</code>s explicitly. See the <a href="tools/Runner$object.html">documentation
 for <code>Runner</code></a> for more information.
 </p>

 <p>
 <strong>Test fixtures</strong>
 </p>

 <p>
 A test <em>fixture</em> is objects or other artifacts (such as files, sockets, database
 connections, etc.) used by tests to do their work.
 If a fixture is used by only one test method, then the definitions of the fixture objects should
 be local to the method, such as the objects assigned to <code>sum</code> and <code>diff</code> in the
 previous <code>MySuite</code> examples. If multiple methods need to share a fixture, the best approach
 is to assign them to instance variables. Here's a (very contrived) example, in which the object assigned
 to <code>shared</code> is used by multiple test methods:
 </p>

 <pre>
 import org.scalatest.Suite

 class MySuite extends Suite {

   // Sharing fixture objects via instance variables
   val shared = 5

   def testAddition() {
     val sum = 2 + 3
     assert(sum === shared)
   }

   def testSubtraction() {
     val diff = 7 - 2
     assert(diff === shared)
   }
 }
 </pre>

 <p>
 In some cases, however, shared <em>mutable</em> fixture objects may be changed by test methods such that
 it needs to be recreated or reinitialized before each test. Shared resources such
 as files or database connections may also need to 
 be cleaned up after each test. JUnit offers methods <code>setup</code> and
 <code>tearDown</code> for this purpose. In ScalaTest, you can use the <code>BeforeAndAfter</code> trait,
 which will be described later, to implement an approach similar to JUnit's <code>setup</code>
 and <code>tearDown</code>, however, this approach often involves reassigning <code>var</code>s
 between tests. Before going that route, you should consider two approaches that
 avoid <code>var</code>s. One approach is to write one or more "create" methods
 that return a new instance of a needed object (or a tuple of new instances of
 multiple objects) each time it is called. You can then call a create method at the beginning of each
 test method that needs the fixture, storing the fixture object or objects in local variables. Here's an example:
 </p>

 <pre>
 import org.scalatest.Suite
 import scala.collection.mutable.ListBuffer

 class MySuite extends Suite {

   // create objects needed by tests and return as a tuple
   def createFixture = (
     new StringBuilder("ScalaTest is "),
     new ListBuffer[String]
   )

   def testEasy() {
     val (builder, lbuf) = createFixture
     builder.append("easy!")
     assert(builder.toString === "ScalaTest is easy!")
     assert(lbuf.isEmpty)
     lbuf += "sweet"
   }

   def testFun() {
     val (builder, lbuf) = createFixture
     builder.append("fun!")
     assert(builder.toString === "ScalaTest is fun!")
     assert(lbuf.isEmpty)
   }
 }
 </pre>

 <p>
 Another approach to mutable fixture objects that avoids <code>var</code>s is to create "with" methods,
 which take test code as a function that takes the fixture objects as parameters, and wrap test code in calls to the "with" method. Here's an example:
 </p>
 <pre>
 import org.scalatest.Suite
 import scala.collection.mutable.ListBuffer

 class MySuite extends Suite {

   def withFixture(testFunction: (StringBuilder, ListBuffer[String]) => Unit) {

     // Create needed mutable objects
     val sb = new StringBuilder("ScalaTest is ")
     val lb = new ListBuffer[String]

     // Invoke the test function, passing in the mutable objects
     testFunction(sb, lb)
   }

   def testEasy() {
     withFixture {
       (builder, lbuf) => {
         builder.append("easy!")
         assert(builder.toString === "ScalaTest is easy!")
         assert(lbuf.isEmpty)
         lbuf += "sweet"
       }
     }
   }

   def testFun() {
     withFixture {
       (builder, lbuf) => {
         builder.append("fun!")
         assert(builder.toString === "ScalaTest is fun!")
         assert(lbuf.isEmpty)
       }
     }
   }
 }
 </pre>
 
 One advantage of this approach compared to the create method approach shown previously is that
 you can more easily perform cleanup after each test executes. For example, you
 could create a temporary file before each test, and delete it afterwords, by
 doing so before and after invoking the test function in a <code>withTempFile</code>
 method. Here's an example:

 <pre>
 import org.scalatest.Suite
 import java.io.FileReader
 import java.io.FileWriter
 import java.io.File
 
 class MySuite extends Suite {
 
   def withTempFile(testFunction: FileReader => Unit) {
 
     val FileName = "TempFile.txt"
  
     // Set up the temp file needed by the test
     val writer = new FileWriter(FileName)
     try {
       writer.write("Hello, test!")
     }
     finally {
       writer.close()
     }
  
     // Create the reader needed by the test
     val reader = new FileReader(FileName)
  
     try {
       // Run the test using the temp file
       testFunction(reader)
     }
     finally {
       // Close and delete the temp file
       reader.close()
       val file = new File(FileName)
       file.delete()
     }
   }
 
   def testReadingFromTheTempFile() {
     withTempFile {
       (reader) => {
         var builder = new StringBuilder
         var c = reader.read()
         while (c != -1) {
           builder.append(c.toChar)
           c = reader.read()
         }
         assert(builder.toString === "Hello, test!")
       }
     }
   }
 
   def testFirstCharOfTheTempFile() {
     withTempFile {
       (reader) => {
         assert(reader.read() === 'H')
       }
     }
   }
 }
 </pre>

 <p>
 If you are more comfortable with reassigning instance variables, however, you can
 instead use the <code>BeforeAndAfter</code> trait, which provides
 methods that will be run before and after each test. <code>BeforeAndAfter</code>'s
 <code>beforeEach</code> method will be run before, and its <code>afterEach</code>
 method after, each test (like JUnit's <code>setup</code>  and <code>tearDown</code>
 methods, respectively). For example, here's how you'd write the previous
 test that uses a temp file with <code>BeforeAndAfter</code>:
 </p>

 <pre>
 import org.scalatest.BeforeAndAfter
 import java.io.FileReader
 import java.io.FileWriter
 import java.io.File

 class MySuite extends Suite with BeforeAndAfter {

   private val FileName = "TempFile.txt"
   private var reader: FileReader = _

   // Set up the temp file needed by the test
   override def beforeEach() {
     val writer = new FileWriter(FileName)
     try {
       writer.write("Hello, test!")
     }
     finally {
       writer.close()
     }

     // Create the reader needed by the test
     reader = new FileReader(FileName)
   }

   // Close and delete the temp file
   override def afterEach() {
     reader.close()
     val file = new File(FileName)
     file.delete()
   }

   def testReadingFromTheTempFile() {
     var builder = new StringBuilder
     var c = reader.read()
     while (c != -1) {
       builder.append(c.toChar)
       c = reader.read()
     }
     assert(builder.toString === "Hello, test!")
   }

   def testFirstCharOfTheTempFile() {
     assert(reader.read() === 'H')
   }
 }
 </pre>

 <p>
 In this example, the instance variable <code>reader</code> is a <code>var</code>, so
 it can be reinitialized between tests by the <code>beforeEach</code> method. If you
 want to execute code before and after all tests (and nested suites) in a suite, such
 as you could do with <code>@BeforeClass</code> and <code>@AfterClass</code>
 annotations in JUnit 4, you can use the <code>beforeAll</code> and <code>afterAll</code>
 methods of <code>BeforeAndAfter</code>. See the documentation for <code>BeforeAndAfter</code> for
 an example.
 </p>

 <p>
 <strong>Goodies</strong>
 </p>

 <p>
 In some cases you may need to pass information from a suite to its nested suites.
 For example, perhaps a main suite needs to open a database connection that is then
 used by all of its nested suites. You can accomplish this in ScalaTest by using
 goodies, which are passed to <code>execute</code> as a <code>Map[String, Any]</code>.
 This trait's <code>execute</code> method calls two other methods, both of which you
 can override:
 </p>

 <ul>
 <li><code>runNestedSuites</code> - responsible for running this <code>Suite</code>'s nested <code>Suite</code>s</li>
 <li><code>runTests</code> - responsible for running this <code>Suite</code>'s tests</li>
 </ul>

 <p>
 To pass goodies to nested <code>Suite</code>s, simply override <code>runNestedSuites</code>.
 Here's an example:
 </p>
 
 <pre>
 import org.scalatest._
 import java.io.FileWriter

 object Constants {
   val GoodieKey = "fixture.FileWriter"
 }

 class NestedSuite extends Suite {

   override def execute(
     testName: Option[String],
     reporter: Reporter,
     stopper: Stopper,
     groupsToInclude: Set[String],
     groupsToExclude: Set[String],
     goodies: Map[String, Any],
     distributor: Option[Distributor]
   ) {
     def complain() = fail("Hey, where's my goodie?")

     if (goodies.contains(Constants.GoodieKey)) {
       goodies(Constants.GoodieKey) match {
         case fw: FileWriter => fw.write("hi there\n") // Use the goodie
         case _ => complain()
       }
     }
     else complain()
   }
 }

 class MainSuite extends SuperSuite(List(new NestedSuite)) {

   override def runNestedSuites(
     reporter: Reporter,
     stopper: Stopper,
     groupsToInclude: Set[String],
     groupsToExclude: Set[String],
     goodies: Map[String, Any],
     distributor: Option[Distributor]
   ) {
     val writer = new FileWriter("fixture.txt")
     try {
       val myGoodies = goodies + (Constants.GoodieKey -> writer)
       super.runNestedSuites(reporter, stopper, groupsToInclude, groupsToExclude, myGoodies, distributor)
     }
     finally {
       writer.close()
     }
   }
 }
 </pre>
 
 <p>
 In this example, <code>MainSuite</code>'s runNestedSuites method opens a file for writing, then passes
 the <code>FileWriter</code> to its <code>NestedSuite</code> via the goodies <code>Map</code>. The <code>NestedSuite</code>
 grabs the <code>FileWriter</code> from the goodies <code>Map</code> and writes a friendly message to the file.
 </p>
 
 <p>
 <strong>Test groups</strong>
 </p>

 <p>
 A <code>Suite</code>'s tests may be classified into named <em>groups</em>. When executing
 a <code>Suite</code>, groups of tests can optionally be included and/or excluded. In this
 trait's implementation, groups are indicated by annotations attached to the test method. To
 create a group, simply define a new Java annotation. (Currently, for annotations to be
 visible in Scala programs via Java reflection, the annotations themselves must be written in Java.) For example,
 to create a group named <code>SlowAsMolasses</code>, to use to mark slow tests, you would
 write in Java:
 </p>

 <pre>
 import java.lang.annotation.*; 
 
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ElementType.METHOD, ElementType.TYPE})
 public @interface SlowAsMolasses {}
 </pre>

 <p>
 Given this new annotation, you could place methods into the <code>SlowAsMolasses</code> group
 like this:
 </p>

 <pre>
 @SlowAsMolasses
 def testSleeping() = sleep(1000000)
 </pre>

 <p>
 The primary execute method takes two <code>Set[String]</code>s called <code>groupsToInclude</code> and
 <code>groupsToExclude</code>. If <code>groupsToInclude</code> is empty, all tests will be executed
 except those those belonging to groups listed in the
 <code>groupsToExclude</code> <code>Set</code>. If <code>groupsToInclude</code> is non-empty, only tests
 belonging to groups mentioned in <code>groupsToInclude</code>, and not mentioned in <code>groupsToExclude</code>,
 will be executed.
 </p>

 <p>
 <strong>Ignored tests</strong>
 </p>

 <p>
 Another common use case is that tests must be &#8220;temporarily&#8221; disabled, with the
 good intention of resurrecting the test at a later time. ScalaTest provides an <code>Ignore</code>
 annotation for this purpose. You use it like this:
 </p>

 <pre>
 import org.scalatest.Suite
 import org.scalatest.Ignore

 class MySuite extends Suite {

   def testAddition() {
     val sum = 1 + 1
     assert(sum === 2)
     assert(sum + 2 === 4)
   }

   @Ignore
   def testSubtraction() {
     val diff = 4 - 1
     assert(diff === 3)
     assert(diff - 2 === 1)
   }
 }
 </pre>

 <p>
 If you run this version of <code>MySuite</code> with:
 </p>

 <pre>
 scala> (new MySuite).execute()
 </pre>

 <p>
 It will run only <code>testAddition</code> and report that <code>testSubtraction</code> was ignored. You'll see:
 </p>

 <pre>
 Test Starting - MySuite.testAddition
 Test Succeeded - MySuite.testAddition
 Test Ignored - MySuite.testSubtraction
 </pre>
 
 <p>
 <code>Ignore</code> is implemented as a group. The <code>execute</code> method that takes no parameters
 adds <code>org.scalatest.Ignore</code> to the <code>groupsToExclude</code> <code>Set</code> it passes to
 the primary <code>execute</code> method, as does <code>Runner</code>. The only difference between
 <code>org.scalatest.Ignore</code> and the groups you may define and exclude is that ScalaTest reports
 ignored tests to the <code>Reporter</code>. The reason ScalaTest reports ignored tests is as a feeble
 attempt to encourage ignored tests to be eventually fixed and added back into the active suite of tests.
 </p>

 <p>
 <strong>Informers</strong>
 </p>

 <p>
 One of the parameters to the primary <code>execute</code> method is an <code>Informer</code>, which
 will collect and report information about the running suite of tests.
 Information about suites and tests that were run, whether tests succeeded or failed, 
 and tests that were ignored will be passed to the <code>Reporter</code> as the suite runs.
 Most often the reporting done by default by <code>Suite</code>'s methods will be sufficient, but
 occasionally you may wish to provide custom information to the <code>Reporter</code> from a test method.
 For this purpose, you can optionally include an <code>Informer</code> parameter in a test method, and then
 pass the extra information to the <code>Informer</code> via one of its <code>apply</code> methods. The <code>Informer</code>
 will then pass the information to the <code>Reporter</code>'s <code>infoProvided</code> method.
 Here's an example:
 </p>

 <pre>
 import org.scalatest._
 
 class MySuite extends Suite {
   def testAddition(info: Informer) {
     assert(1 + 1 === 2)
     info("Addition seems to work")
   }
 }
 </pre>

 If you run this <code>Suite</code> from the interpreter, you will see the message
 included in the printed report:

 <pre>
 scala> (new MySuite).execute()
 Test Starting - MySuite.testAddition(Reporter)
 Info Provided - MySuite.testAddition(Reporter): Addition seems to work
 Test Succeeded - MySuite.testAddition(Reporter)
 </pre>

 <p>
 <strong>Executing suites concurrently</strong>
 </p>

 <p>
 The primary <code>execute</code> method takes as its last parameter an optional <code>Distributor</code>. If 
 a <code>Distributor</code> is passed in, this trait's implementation of <code>execute</code> puts its nested
 <code>Suite</code>s into the distributor rather than executing them directly. The caller of <code>execute</code>
 is responsible for ensuring that some entity executes the <code>Suite</code>s placed into the 
 distributor. The <code>-c</code> command line parameter to <code>Runner</code>, for example, will cause
 <code>Suite</code>s put into the <code>Distributor</code> to be executed concurrently via a pool of threads.
 </p>

 <p>
 <strong>Extensibility</strong>
 </p>

 <p>
 Trait <code>Suite</code> provides default implementations of its methods that should
 be sufficient for most applications, but many methods can be overridden when desired. Here's
 a summary of the methods that are intended to be overridden:
 </p>

 <ul>
 <li><code>execute</code> - override this method to define custom ways to executes suites of
   tests.</li>
 <li><code>runTest</code> - override this method to define custom ways to execute a single named test.</li>
 <li><code>testNames</code> - override this method to specify the <code>Suite</code>'s test names in a custom way.</li>
 <li><code>groups</code> - override this method to specify the <code>Suite</code>'s test groups in a custom way.</li>
 <li><code>nestedSuites</code> - override this method to specify the <code>Suite</code>'s nested <code>Suite</code>s in a custom way.</li>
 <li><code>suiteName</code> - override this method to specify the <code>Suite</code>'s name in a custom way.</li>
 <li><code>expectedTestCount</code> - override this method to count this <code>Suite</code>'s expected tests in a custom way.</li>
 </ul>

 <p>
 For example, this trait's implementation of <code>testNames</code> performs reflection to discover methods starting with <code>test</code>,
 and places these in a <code>Set</code> whose iterator returns the names in alphabetical order. If you wish to run tests in a different
 order in a particular <code>Suite</code>, perhaps because a test named <code>testAlpha</code> can only succeed after a test named
 <code>testBeta</code> has run, you can override <code>testNames</code> so that it returns a <code>Set</code> whose iterator returns
 <code>testBeta</code> <em>before</em> <code>testAlpha</code>. (This trait's implementation of <code>execute</code> will invoke tests
 in the order they come out of the <code>testNames</code> <code>Set</code> iterator.)
 </p>

 <p>
 Alternatively, you may not like starting your test methods with <code>test</code>, and prefer using <code>@Test</code> annotations in
 the style of Java's JUnit 4 or TestNG. If so, you can override <code>testNames</code> to discover tests using either of these two APIs
 <code>@Test</code> annotations, or one of your own invention. (This is in fact
 how <code>org.scalatest.junit.JUnit4Suite</code> and <code>org.scalatest.testng.TestNGSuite</code> work.)
 </p>

 <p>
 Moreover, <em>test</em> in ScalaTest does not necessarily mean <em>test method</em>. A test can be anything that can be given a name,
 that starts and either succeeds or fails, and can be ignored. In <code>org.scalatest.FunSuite</code>, for example, tests are represented
 as function values. This
 approach might look foreign to JUnit users, but may feel more natural to programmers with a functional programming background.
 To facilitate this style of writing tests, <code>FunSuite</code> overrides <code>testNames</code>, <code>runTest</code>, and <code>execute</code> such that you can 
 define tests as function values.
 </p>

 <p>
 You can also model existing JUnit 3, JUnit 4, or TestNG tests as suites of tests, thereby incorporating Java tests into a ScalaTest suite.
 The "wrapper" classes in packages <code>org.scalatest.junit</code> and <code>org.scalatest.testng</code> exist to make this easy. The point here, however, is that
 no matter what legacy tests you may have, it is likely you can create or use an existing <code>Suite</code> subclass that allows you to model those tests
 as ScalaTest suites and tests and incorporate them into a ScalaTest suite. You can then write new tests in Scala and continue supporting
 older tests in Java.
 </p></dd></dl>
      <dl><dt style="margin:10px 0 0 20px;">
        <b>Author</b></dt><dd>Bill Venners</dd></dl>
    <dl>
      <dt style="margin:10px 0 0 20px;"><b>Direct Known Subclasses:</b></dt>
      <dd><a href="../../org/scalatest/FunSuite.html" target="_self">FunSuite</a>, <a href="../../org/scalatest/ImpSuite.html" target="_self">ImpSuite</a>, <a href="../../org/scalatest/Spec.html" target="_self">Spec</a>, <a href="../../org/scalatest/SuperSuite.html" target="_self">SuperSuite</a>, <a href="../../org/scalatest/junit/JUnit3Suite.html" target="_self">JUnit3Suite</a>, <a href="../../org/scalatest/testng/TestNGSuite.html" target="_self">TestNGSuite</a></dd>
      </dl><hr></hr>
      


<table summary="" cellpadding="3" class="member">
      <tr><td class="title" colspan="2">Method Summary</td></tr>
      <tr>
      <td class="modifiers" valign="top"> 
        <code>final def</code>
      </td>
      <td class="signature">
        <em><a href="../../org/scalatest/Suite.html#execute%28String%29" target="_self">execute</a></em>
        (<em>testName</em> : <a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>) : <a href="http://www.scala-lang.org/docu/files/api/scala/Unit.html" target="_self">Unit</a>
        
        <div>Executes the test specified <code>testName</code> in this <code>Suite</code>, printing results to the standard output. This method
   implementation calls on this <code>Suite</code> the <code>execute</code> method that takes
   seven parameters, passing in:
  
   <ul>
   <li><code>testName</code> - <code>Some(testName)</code></li>
   <li><code>reporter</code> - a reporter that prints to the standard output</li>
   <li><code>stopper</code> - a <code>Stopper</code> whose <code>stopRequested</code> method always returns <code>false</code></li>
   <li><code>groupsToInclude</code> - an empty <code>Set[String]</code></li>
   <li><code>groupsToExclude</code> - an empty <code>Set[String]</code></li>
   <li><code>goodies</code> - an empty <code>Map[String, Any]</code></li>
   <li><code>distributor</code> - <code>None</code></li>
   </ul></div>
      </td>
    </tr>
<tr>
      <td class="modifiers" valign="top"> 
        <code> def</code>
      </td>
      <td class="signature">
        <em><a href="../../org/scalatest/Suite.html#execute%28Option%5BString%5D%2Corg.scalatest.Reporter%2Corg.scalatest.Stopper%2CSet%5BString%5D%2CSet%5BString%5D%2CMap%5BString%2CAny%5D%2COption%5Borg.scalatest.Distributor%5D%29" target="_self">execute</a></em>
        (<em>testName</em> : <a href="" target="contentFrame" class="scala/Option">scala.Option</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>reporter</em> : <a href="../../org/scalatest/Reporter.html" target="_self">Reporter</a>, <em>stopper</em> : <a href="../../org/scalatest/Stopper.html" target="_self">Stopper</a>, <em>groupsToInclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>groupsToExclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>goodies</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Map">scala.collection.immutable.Map</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/Any.html" target="_self">Any</a>], <em>distributor</em> : <a href="" target="contentFrame" class="scala/Option">scala.Option</a>[<a href="../../org/scalatest/Distributor.html" target="_self">Distributor</a>]) : <a href="http://www.scala-lang.org/docu/files/api/scala/Unit.html" target="_self">Unit</a>
        
        <div>Execute this <code>Suite</code>.</div>
      </td>
    </tr>
<tr>
      <td class="modifiers" valign="top"> 
        <code>final def</code>
      </td>
      <td class="signature">
        <em><a href="../../org/scalatest/Suite.html#execute%28%29" target="_self">execute</a></em>
         : <a href="http://www.scala-lang.org/docu/files/api/scala/Unit.html" target="_self">Unit</a>
        
        <div>Executes this <code>Suite</code>, printing results to the standard output. This method
   implementation calls on this <code>Suite</code> the <code>execute</code> method that takes
   seven parameters, passing in:
  
   <ul>
   <li><code>testName</code> - <code>None</code></li>
   <li><code>reporter</code> - a reporter that prints to the standard output</li>
   <li><code>stopper</code> - a <code>Stopper</code> whose <code>stopRequested</code> method always returns <code>false</code></li>
   <li><code>groupsToInclude</code> - an empty <code>Set[String]</code></li>
   <li><code>groupsToExclude</code> - an <code>Set[String]</code> that contains only one element, <code>"org.scalatest.Ignore"</code></li>
   <li><code>goodies</code> - an empty <code>Map[String, Any]</code></li>
   <li><code>distributor</code> - <code>None</code></li>
   </ul></div>
      </td>
    </tr>
<tr>
      <td class="modifiers" valign="top"> 
        <code> def</code>
      </td>
      <td class="signature">
        <em><a href="../../org/scalatest/Suite.html#expectedTestCount%28Set%5BString%5D%2CSet%5BString%5D%29" target="_self">expectedTestCount</a></em>
        (<em>groupsToInclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>groupsToExclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>]) : <a href="http://www.scala-lang.org/docu/files/api/scala/Int.html" target="_self">Int</a>
        
        <div>The total number of tests that are expected to run when this <code>Suite</code>'s <code>execute</code> method is invoked.
   This trait's implementation of this method returns the sum of:
  
   <ul>
   <li>the size of the <code>testNames</code> <code>List</code>
   <li>the sum of the values obtained by invoking
       <code>expecteTestCount</code> on every nested <code>Suite</code> contained in
       <code>nestedSuites</code>
   </ul></div>
      </td>
    </tr>
<tr>
      <td class="modifiers" valign="top"> 
        <code> def</code>
      </td>
      <td class="signature">
        <em><a href="../../org/scalatest/Suite.html#groups" target="_self">groups</a></em>
         : <a href="" target="contentFrame" class="scala/collection/immutable/Map">scala.collection.immutable.Map</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>, <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>]]
        
        <div>A <code>Map</code> whose keys are <code>String</code> group names to which tests in this <code>Suite</code> belong, and values
   the <code>Set</code> of test names that belong to each group.  If this <code>Suite</code> contains no groups, this method returns an empty <code>Map</code>.</div>
      </td>
    </tr>
<tr>
      <td class="modifiers" valign="top"> 
        <code> def</code>
      </td>
      <td class="signature">
        <em><a href="../../org/scalatest/Suite.html#nestedSuites" target="_self">nestedSuites</a></em>
         : <a href="" target="contentFrame" class="scala/List">scala.List</a>[<a href="../../org/scalatest/Suite.html" target="_self">Suite</a>]
        
        <div>A <code>List</code> of this <code>Suite</code> object's nested <code>Suite</code>s. If this <code>Suite</code> contains no nested <code>Suite</code>s,
  this method returns an empty <code>List</code>. This trait's implementation of this method returns an empty <code>List</code>.</div>
      </td>
    </tr>
<tr>
      <td class="modifiers" valign="top"> 
        <code>protected def</code>
      </td>
      <td class="signature">
        <em><a href="../../org/scalatest/Suite.html#runNestedSuites%28org.scalatest.Reporter%2Corg.scalatest.Stopper%2CSet%5BString%5D%2CSet%5BString%5D%2CMap%5BString%2CAny%5D%2COption%5Borg.scalatest.Distributor%5D%29" target="_self">runNestedSuites</a></em>
        (<em>reporter</em> : <a href="../../org/scalatest/Reporter.html" target="_self">Reporter</a>, <em>stopper</em> : <a href="../../org/scalatest/Stopper.html" target="_self">Stopper</a>, <em>groupsToInclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>groupsToExclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>goodies</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Map">scala.collection.immutable.Map</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/Any.html" target="_self">Any</a>], <em>distributor</em> : <a href="" target="contentFrame" class="scala/Option">scala.Option</a>[<a href="../../org/scalatest/Distributor.html" target="_self">Distributor</a>]) : <a href="http://www.scala-lang.org/docu/files/api/scala/Unit.html" target="_self">Unit</a>
        
        <div></div>
      </td>
    </tr>
<tr>
      <td class="modifiers" valign="top"> 
        <code>protected def</code>
      </td>
      <td class="signature">
        <em><a href="../../org/scalatest/Suite.html#runTest%28String%2Corg.scalatest.Reporter%2Corg.scalatest.Stopper%2CMap%5BString%2CAny%5D%29" target="_self">runTest</a></em>
        (<em>testName</em> : <a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>, <em>reporter</em> : <a href="../../org/scalatest/Reporter.html" target="_self">Reporter</a>, <em>stopper</em> : <a href="../../org/scalatest/Stopper.html" target="_self">Stopper</a>, <em>goodies</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Map">scala.collection.immutable.Map</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/Any.html" target="_self">Any</a>]) : <a href="http://www.scala-lang.org/docu/files/api/scala/Unit.html" target="_self">Unit</a>
        
        <div>Run a test. This trait's implementation uses Java reflection to invoke on this object the test method identified by the passed <code>testName</code>.</div>
      </td>
    </tr>
<tr>
      <td class="modifiers" valign="top"> 
        <code>protected def</code>
      </td>
      <td class="signature">
        <em><a href="../../org/scalatest/Suite.html#runTests%28Option%5BString%5D%2Corg.scalatest.Reporter%2Corg.scalatest.Stopper%2CSet%5BString%5D%2CSet%5BString%5D%2CMap%5BString%2CAny%5D%29" target="_self">runTests</a></em>
        (<em>testName</em> : <a href="" target="contentFrame" class="scala/Option">scala.Option</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>reporter</em> : <a href="../../org/scalatest/Reporter.html" target="_self">Reporter</a>, <em>stopper</em> : <a href="../../org/scalatest/Stopper.html" target="_self">Stopper</a>, <em>groupsToInclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>groupsToExclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>goodies</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Map">scala.collection.immutable.Map</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/Any.html" target="_self">Any</a>]) : <a href="http://www.scala-lang.org/docu/files/api/scala/Unit.html" target="_self">Unit</a>
        
        <div></div>
      </td>
    </tr>
<tr>
      <td class="modifiers" valign="top"> 
        <code> def</code>
      </td>
      <td class="signature">
        <em><a href="../../org/scalatest/Suite.html#suiteName" target="_self">suiteName</a></em>
         : <a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>
        
        <div>A user-friendly suite name for this <code>Suite</code>. This trait's
   implementation of this method returns the simple name of this object's class. This
   trait's implementation of <code>runNestedSuites</code> calls this method to obtain a
   name for <code>Report</code>s to pass to the <code>suiteStarting</code>, <code>suiteCompleted</code>,
   and <code>suiteAborted</code> methods of the <code>Reporter</code>.</div>
      </td>
    </tr>
<tr>
      <td class="modifiers" valign="top"> 
        <code> def</code>
      </td>
      <td class="signature">
        <em><a href="../../org/scalatest/Suite.html#testNames" target="_self">testNames</a></em>
         : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>]
        
        <div>An immutable <code>Set</code> of test names. If this <code>Suite</code> contains no tests, this method returns an empty <code>Set</code>.</div>
      </td>
    </tr>
      </table><table summary="" cellpadding="3" class="inherited">
        <tr><td class="title" colspan="2">
          Methods inherited from <a href="../../org/scalatest/Assertions.html" target="_self">Assertions</a>
        </td></tr>
        <tr><td class="signature" colspan="2">
          <a href="../../org/scalatest/Assertions.html#assert%28Boolean%29" target="_self">assert</a>, <a href="../../org/scalatest/Assertions.html#assert%28Boolean%2CAny%29" target="_self">assert</a>, <a href="../../org/scalatest/Assertions.html#assert%28Option%5BString%5D%2CAny%29" target="_self">assert</a>, <a href="../../org/scalatest/Assertions.html#assert%28Option%5BString%5D%29" target="_self">assert</a>, <a href="../../org/scalatest/Assertions.html#convertToEqualizer%28Any%29" target="_self">convertToEqualizer</a>, <a href="../../org/scalatest/Assertions.html#intercept%28java.lang.Class%5BT%5D%2CAny%29" target="_self">intercept</a>, <a href="../../org/scalatest/Assertions.html#intercept%28java.lang.Class%5BT%5D%29" target="_self">intercept</a>, <a href="../../org/scalatest/Assertions.html#intercept%28%3D%3EAny%29" target="_self">intercept</a>, <a href="../../org/scalatest/Assertions.html#expect%28Any%2CAny%29" target="_self">expect</a>, <a href="../../org/scalatest/Assertions.html#expect%28Any%29" target="_self">expect</a>, <a href="../../org/scalatest/Assertions.html#fail%28%29" target="_self">fail</a>, <a href="../../org/scalatest/Assertions.html#fail%28String%29" target="_self">fail</a>, <a href="../../org/scalatest/Assertions.html#fail%28String%2CThrowable%29" target="_self">fail</a>, <a href="../../org/scalatest/Assertions.html#fail%28Throwable%29" target="_self">fail</a>
        </td></tr>
      </table><table summary="" cellpadding="3" class="inherited">
        <tr><td class="title" colspan="2">
          Methods inherited from <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html" target="_self">AnyRef</a>
        </td></tr>
        <tr><td class="signature" colspan="2">
          <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#getClass%28%29" target="_self">getClass</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#hashCode%28%29" target="_self">hashCode</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#equals%28Any%29" target="_self">equals</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#clone%28%29" target="_self">clone</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#toString%28%29" target="_self">toString</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#notify%28%29" target="_self">notify</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#notifyAll%28%29" target="_self">notifyAll</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#wait%28Long%29" target="_self">wait</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#wait%28Long%2CInt%29" target="_self">wait</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#wait%28%29" target="_self">wait</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#finalize%28%29" target="_self">finalize</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#%3D%3D%28AnyRef%29" target="_self">==</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#%21%3D%28AnyRef%29" target="_self">!=</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#eq%28AnyRef%29" target="_self">eq</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#ne%28AnyRef%29" target="_self">ne</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/AnyRef.html#synchronized%28T0%29" target="_self">synchronized</a>
        </td></tr>
      </table><table summary="" cellpadding="3" class="inherited">
        <tr><td class="title" colspan="2">
          Methods inherited from <a href="http://www.scala-lang.org/docu/files/api/scala/Any.html" target="_self">Any</a>
        </td></tr>
        <tr><td class="signature" colspan="2">
          <a href="http://www.scala-lang.org/docu/files/api/scala/Any.html#%3D%3D%28Any%29" target="_self">==</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/Any.html#%21%3D%28Any%29" target="_self">!=</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/Any.html#isInstanceOf" target="_self">isInstanceOf</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/Any.html#asInstanceOf" target="_self">asInstanceOf</a>
        </td></tr>
      </table>


      


<table summary="" cellpadding="3" class="member-detail">
          <tr><td class="title">Method Details</td></tr>
        </table><div><a name="nestedSuites"></a><dl>
      <dt>
        
        <code></code>
        <code>def</code>
        <em>nestedSuites</em> : <a href="" target="contentFrame" class="scala/List">scala.List</a>[<a href="../../org/scalatest/Suite.html" target="_self">Suite</a>]
      </dt>
      <dd></dd>
    </dl>
      <dl><dd>A <code>List</code> of this <code>Suite</code> object's nested <code>Suite</code>s. If this <code>Suite</code> contains no nested <code>Suite</code>s,
  this method returns an empty <code>List</code>. This trait's implementation of this method returns an empty <code>List</code>.</dd></dl>
      <dl></dl>
    <hr></hr>
<a name="execute%28%29"></a><dl>
      <dt>
        
        <code>final</code>
        <code>def</code>
        <em>execute</em> : <a href="http://www.scala-lang.org/docu/files/api/scala/Unit.html" target="_self">Unit</a>
      </dt>
      <dd></dd>
    </dl>
      <dl><dd>Executes this <code>Suite</code>, printing results to the standard output. This method
   implementation calls on this <code>Suite</code> the <code>execute</code> method that takes
   seven parameters, passing in:
  
   <ul>
   <li><code>testName</code> - <code>None</code></li>
   <li><code>reporter</code> - a reporter that prints to the standard output</li>
   <li><code>stopper</code> - a <code>Stopper</code> whose <code>stopRequested</code> method always returns <code>false</code></li>
   <li><code>groupsToInclude</code> - an empty <code>Set[String]</code></li>
   <li><code>groupsToExclude</code> - an <code>Set[String]</code> that contains only one element, <code>"org.scalatest.Ignore"</code></li>
   <li><code>goodies</code> - an empty <code>Map[String, Any]</code></li>
   <li><code>distributor</code> - <code>None</code></li>
   </ul>
  
   <p>
   This method serves as a convenient way to execute a <code>Suite</code>, especially from within the Scala interpreter.
   </p></dd></dl>
      <dl></dl>
    <hr></hr>
<a name="execute%28String%29"></a><dl>
      <dt>
        
        <code>final</code>
        <code>def</code>
        <em>execute</em>(<em>testName</em> : <a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>) : <a href="http://www.scala-lang.org/docu/files/api/scala/Unit.html" target="_self">Unit</a>
      </dt>
      <dd></dd>
    </dl>
      <dl><dd>Executes the test specified <code>testName</code> in this <code>Suite</code>, printing results to the standard output. This method
   implementation calls on this <code>Suite</code> the <code>execute</code> method that takes
   seven parameters, passing in:
  
   <ul>
   <li><code>testName</code> - <code>Some(testName)</code></li>
   <li><code>reporter</code> - a reporter that prints to the standard output</li>
   <li><code>stopper</code> - a <code>Stopper</code> whose <code>stopRequested</code> method always returns <code>false</code></li>
   <li><code>groupsToInclude</code> - an empty <code>Set[String]</code></li>
   <li><code>groupsToExclude</code> - an empty <code>Set[String]</code></li>
   <li><code>goodies</code> - an empty <code>Map[String, Any]</code></li>
   <li><code>distributor</code> - <code>None</code></li>
   </ul>
  
   <p>
   This method serves as a convenient way to execute a single test, especially from within the Scala interpreter.
   </p></dd></dl>
      <dl></dl>
    <hr></hr>
<a name="groups"></a><dl>
      <dt>
        
        <code></code>
        <code>def</code>
        <em>groups</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Map">scala.collection.immutable.Map</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>, <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>]]
      </dt>
      <dd></dd>
    </dl>
      <dl><dd>A <code>Map</code> whose keys are <code>String</code> group names to which tests in this <code>Suite</code> belong, and values
   the <code>Set</code> of test names that belong to each group.  If this <code>Suite</code> contains no groups, this method returns an empty <code>Map</code>.
  
   <p>
   This trait's implementation uses Java reflection to discover any Java annotations attached to its test methods. Each unique
   annotation name is considered a group. This trait's implementation, therefore, places one key/value pair into to the
   <code>Map</code> for each unique annotation name discovered through reflection. The value for each group name key will contain
   the test method name, as provided via the <code>testNames</code> method. 
   </p>
  
   <p>
   Subclasses may override this method to define and/or discover groups in a custom manner, but overriding method implementations
   should never return an empty <code>Set</code> as a value. If a group has no tests, its name should not appear as a key in the
   returned <code>Map</code>.
   </p></dd></dl>
      <dl></dl>
    <hr></hr>
<a name="testNames"></a><dl>
      <dt>
        
        <code></code>
        <code>def</code>
        <em>testNames</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>]
      </dt>
      <dd></dd>
    </dl>
      <dl><dd>An immutable <code>Set</code> of test names. If this <code>Suite</code> contains no tests, this method returns an empty <code>Set</code>.
 
  <p>
  This trait's implementation of this method uses Java reflection to discover all public methods whose name starts with <code>"test"</code>,
  which take either nothing or a single <code>Informer</code> as parameters. For each discovered test method, it assigns a test name
  comprised of just the method name if the method takes no parameters, or the method name plus <code>(Informer)</code> if the
  method takes a <code>Informer</code>. Here are a few method signatures and the names that this trait's implementation assigns them:
  </p>
 
  <pre>
  def testCat() {}         // test name: "testCat"
  def testCat(Informer) {} // test name: "testCat(Informer)"
  def testDog() {}         // test name: "testDog"
  def testDog(Informer) {} // test name: "testDog(Informer)"
  def test() {}            // test name: "test"
  def test(Informer) {}    // test name: "test(Informer)"
  </pre>
 
  <p>
  This trait's implementation of this method returns an immutable <code>Set</code> of all such names, excluding the name
  <code>testName</code>. The iterator obtained by invoking <code>elements</code> on this
  returned <code>Set</code> will produce the test names in their <em>natural order</em>, as determined by <code>String</code>'s
  <code>compareTo</code> method.
  </p>
 
  <p>
  This trait's implementation of <code>runTests</code> invokes this method
  and calls <code>runTest</code> for each test name in the order they appear in the returned <code>Set</code>'s iterator.
  Although this trait's implementation of this method returns a <code>Set</code> whose iterator produces <code>String</code>
  test names in a well-defined order, the contract of this method does not required a defined order. Subclasses are free to
  override this method and return test names in an undefined order, or in a defined order that's different from <code>String</code>'s
  natural order.
  </p>
 
  <p>
  Subclasses may override this method to produce test names in a custom manner. One potential reason to override <code>testNames</code> is
  to execute tests in a different order, for example, to ensure that tests that depend on other tests are run after those other tests.
  Another potential reason to override is to discover test methods annotated with JUnit 4 or TestNG <code>@Test</code> annotations. Or
  a subclass could override this method and return a static, hard-coded <code>Set</code> of tests, etc.
  </p></dd></dl>
      <dl></dl>
    <hr></hr>
<a name="runTest%28String%2Corg.scalatest.Reporter%2Corg.scalatest.Stopper%2CMap%5BString%2CAny%5D%29"></a><dl>
      <dt>
        
        <code>protected</code>
        <code>def</code>
        <em>runTest</em>(<em>testName</em> : <a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>, <em>reporter</em> : <a href="../../org/scalatest/Reporter.html" target="_self">Reporter</a>, <em>stopper</em> : <a href="../../org/scalatest/Stopper.html" target="_self">Stopper</a>, <em>goodies</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Map">scala.collection.immutable.Map</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/Any.html" target="_self">Any</a>]) : <a href="http://www.scala-lang.org/docu/files/api/scala/Unit.html" target="_self">Unit</a>
      </dt>
      <dd></dd>
    </dl>
      <dl><dd>Run a test. This trait's implementation uses Java reflection to invoke on this object the test method identified by the passed <code>testName</code>.</dd></dl>
      <dl><dt style="margin:10px 0 0 20px;">
        <b>Parameters</b></dt><dd><code>testName - </code>the name of one test to execute.</dd><dd><code>reporter - </code>the <code>Reporter</code> to which results will be reported</dd><dd><code>stopper - </code>the <code>Stopper</code> that will be consulted to determine whether to stop execution early.</dd><dd><code>goodies - </code>a <code>Map</code> of key-value pairs that can be used by the executing <code>Suite</code> of tests.</dd><dt style="margin:10px 0 0 20px;">
        <b>Throws</b></dt><dd><code>NullPointerException - </code>if any of <code>testName</code>, <code>reporter</code>, <code>stopper</code>, or <code>goodies</code>       is <code>null</code>.</dd></dl>
    <dl>
        <dt style="margin:10px 0 0 20px;">
          <b>Overrides</b>
        </dt>
        <dd>
        <a href="../../org/scalatest/ExecuteAndRun.html" target="_self">ExecuteAndRun</a>.<a href="../../org/scalatest/ExecuteAndRun.html#runTest%28String%2Corg.scalatest.Reporter%2Corg.scalatest.Stopper%2CMap%5BString%2CAny%5D%29" target="_self">runTest</a>
        </dd>
      </dl><hr></hr>
<a name="runTests%28Option%5BString%5D%2Corg.scalatest.Reporter%2Corg.scalatest.Stopper%2CSet%5BString%5D%2CSet%5BString%5D%2CMap%5BString%2CAny%5D%29"></a><dl>
      <dt>
        
        <code>protected</code>
        <code>def</code>
        <em>runTests</em>(<em>testName</em> : <a href="" target="contentFrame" class="scala/Option">scala.Option</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>reporter</em> : <a href="../../org/scalatest/Reporter.html" target="_self">Reporter</a>, <em>stopper</em> : <a href="../../org/scalatest/Stopper.html" target="_self">Stopper</a>, <em>groupsToInclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>groupsToExclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>goodies</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Map">scala.collection.immutable.Map</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/Any.html" target="_self">Any</a>]) : <a href="http://www.scala-lang.org/docu/files/api/scala/Unit.html" target="_self">Unit</a>
      </dt>
      <dd></dd>
    </dl>
      <dl><dd><p>
   Run zero to many of this <code>Suite</code>'s tests.
   </p>
  
   <p>
   This method takes a <code>testName</code> parameter that optionally specifies a test to invoke.
   If <code>testName</code> is <code>Some</code>, this trait's implementation of this method 
   invokes <code>runTest</code> on this object, passing in:
   </p>
  
   <ul>
   <li><code>testName</code> - the <code>String</code> value of the <code>testName</code> <code>Option</code> passed
     to this method</li>
   <li><code>reporter</code> - the <code>Reporter</code> passed to this method, or one that wraps and delegates to it</li>
   <li><code>stopper</code> - the <code>Stopper</code> passed to this method, or one that wraps and delegates to it</li>
   <li><code>goodies</code> - the <code>goodies</code> <code>Map</code> passed to this method, or one that wraps and delegates to it</li>
   </ul>
  
   <p>
   This method takes a <code>Set</code> of group names that should be included (<code>groupsToInclude</code>), and a <code>Set</code>
   that should be excluded (<code>groupsToExclude</code>), when deciding which of this <code>Suite</code>'s tests to execute.
   If <code>groupsToInclude</code> is empty, all tests will be executed
   except those those belonging to groups listed in the <code>groupsToExclude</code> <code>Set</code>. If <code>groupsToInclude</code> is non-empty, only tests
   belonging to groups mentioned in <code>groupsToInclude</code>, and not mentioned in <code>groupsToExclude</code>
   will be executed. However, if <code>testName</code> is <code>Some</code>, <code>groupsToInclude</code> and <code>groupsToExclude</code> are essentially ignored.
   Only if <code>testName</code> is <code>None</code> will <code>groupsToInclude</code> and <code>groupsToExclude</code> be consulted to
   determine which of the tests named in the <code>testNames</code> <code>Set</code> should be run. This trait's implementation
   behaves this way, and it is part of the general contract of this method, so all overridden forms of this method should behave
   this way as well.  For more information on trait groups, see the main documentation for this trait.
   </p>
  
   <p>
   If <code>testName</code> is <code>None</code>, this trait's implementation of this method
   invokes <code>testNames</code> on this <code>Suite</code> to get a <code>Set</code> of names of tests to potentially execute.
   (A <code>testNames</code> value of <code>None</code> essentially acts as a wildcard that means all tests in
   this <code>Suite</code> that are selected by <code>groupsToInclude</code> and <code>groupsToExclude</code> should be executed.)
   For each test in the <code>testName</code> <code>Set</code>, in the order
   they appear in the iterator obtained by invoking the <code>elements</code> method on the <code>Set</code>, this trait's implementation
   of this method checks whether the test should be run based on the <code>groupsToInclude</code> and <code>groupsToExclude</code> <code>Set</code>s.
   If so, this implementation invokes <code>runTest</code>, passing in:
   </p>
  
   <ul>
   <li><code>testName</code> - the <code>String</code> name of the test to run (which will be one of the names in the <code>testNames</code> <code>Set</code>)</li>
   <li><code>reporter</code> - the <code>Reporter</code> passed to this method, or one that wraps and delegates to it</li>
   <li><code>stopper</code> - the <code>Stopper</code> passed to this method, or one that wraps and delegates to it</li>
   <li><code>goodies</code> - the <code>goodies</code> <code>Map</code> passed to this method, or one that wraps and delegates to it</li>
   </ul></dd></dl>
      <dl><dt style="margin:10px 0 0 20px;">
        <b>Parameters</b></dt><dd><code>testName - </code>an optional name of one test to execute. If <code>None</code>, all relevant tests should be executed.                   I.e., <code>None</code> acts like a wildcard that means execute all relevant tests in this <code>Suite</code>.</dd><dd><code>reporter - </code>the <code>Reporter</code> to which results will be reported</dd><dd><code>stopper - </code>the <code>Stopper</code> that will be consulted to determine whether to stop execution early.</dd><dd><code>groupsToInclude - </code>a <code>Set</code> of <code>String</code> group names to include in the execution of this <code>Suite</code></dd><dd><code>groupsToExclude - </code>a <code>Set</code> of <code>String</code> group names to exclude in the execution of this <code>Suite</code></dd><dd><code>goodies - </code>a <code>Map</code> of key-value pairs that can be used by the executing <code>Suite</code> of tests.</dd><dt style="margin:10px 0 0 20px;">
        <b>Throws</b></dt><dd><code>NullPointerException - </code>if any of <code>testName</code>, <code>reporter</code>, <code>stopper</code>, <code>groupsToInclude</code>,       <code>groupsToExclude</code>, or <code>goodies</code> is <code>null</code>.
  
   This trait's implementation of this method executes tests
   in the manner described in detail in the following paragraphs, but subclasses may override the method to provide different
   behavior. The most common reason to override this method is to set up and, if also necessary, to clean up a test fixture
   used by all the methods of this <code>Suite</code>.</dd></dl>
    <hr></hr>
<a name="execute%28Option%5BString%5D%2Corg.scalatest.Reporter%2Corg.scalatest.Stopper%2CSet%5BString%5D%2CSet%5BString%5D%2CMap%5BString%2CAny%5D%2COption%5Borg.scalatest.Distributor%5D%29"></a><dl>
      <dt>
        
        <code></code>
        <code>def</code>
        <em>execute</em>(<em>testName</em> : <a href="" target="contentFrame" class="scala/Option">scala.Option</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>reporter</em> : <a href="../../org/scalatest/Reporter.html" target="_self">Reporter</a>, <em>stopper</em> : <a href="../../org/scalatest/Stopper.html" target="_self">Stopper</a>, <em>groupsToInclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>groupsToExclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>goodies</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Map">scala.collection.immutable.Map</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/Any.html" target="_self">Any</a>], <em>distributor</em> : <a href="" target="contentFrame" class="scala/Option">scala.Option</a>[<a href="../../org/scalatest/Distributor.html" target="_self">Distributor</a>]) : <a href="http://www.scala-lang.org/docu/files/api/scala/Unit.html" target="_self">Unit</a>
      </dt>
      <dd></dd>
    </dl>
      <dl><dd>Execute this <code>Suite</code>.
  
   <p>If <code>testName</code> is <code>None</code>, this trait's implementation of this method
   calls these two methods on this object in this order:</p>
  
   <ol>
   <li><code>runNestedSuites(wrappedReporter, stopper, groupsToInclude, groupsToExclude, goodies, distributor)</code></li>
   <li><code>runTests(testName, wrappedReporter, stopper, groupsToInclude, groupsToExclude, goodies)</code></li>
   </ol>
  
   <p>
   If <code>testName</code> is <code>Some</code>, then this trait's implementation of this method
   calls <code>runTests</code>, but does not call <code>runNestedSuites</code>.
   </p></dd></dl>
      <dl><dt style="margin:10px 0 0 20px;">
        <b>Parameters</b></dt><dd><code>testName - </code>an optional name of one test to execute. If <code>None</code>, all relevant tests should be executed.                   I.e., <code>None</code> acts like a wildcard that means execute all relevant tests in this <code>Suite</code>.</dd><dd><code>reporter - </code>the <code>Reporter</code> to which results will be reported</dd><dd><code>stopper - </code>the <code>Stopper</code> that will be consulted to determine whether to stop execution early.</dd><dd><code>groupsToInclude - </code>a <code>Set</code> of <code>String</code> group names to include in the execution of this <code>Suite</code></dd><dd><code>groupsToExclude - </code>a <code>Set</code> of <code>String</code> group names to exclude in the execution of this <code>Suite</code></dd><dd><code>goodies - </code>a <code>Map</code> of key-value pairs that can be used by the executing <code>Suite</code> of tests.</dd><dd><code>distributor - </code>an optional <code>Distributor</code>, into which to put nested <code>Suite</code>s to be executed                by another entity, such as concurrently by a pool of threads. If <code>None</code>, nested <code>Suite</code>s will be executed sequentially.</dd><dt style="margin:10px 0 0 20px;">
        <b>Throws</b></dt><dd><code>NullPointerException - </code>if any passed parameter is <code>null</code>.</dd></dl>
    <dl>
        <dt style="margin:10px 0 0 20px;">
          <b>Overrides</b>
        </dt>
        <dd>
        <a href="../../org/scalatest/ExecuteAndRun.html" target="_self">ExecuteAndRun</a>.<a href="../../org/scalatest/ExecuteAndRun.html#execute%28Option%5BString%5D%2Corg.scalatest.Reporter%2Corg.scalatest.Stopper%2CSet%5BString%5D%2CSet%5BString%5D%2CMap%5BString%2CAny%5D%2COption%5Borg.scalatest.Distributor%5D%29" target="_self">execute</a>
        </dd>
      </dl><hr></hr>
<a name="runNestedSuites%28org.scalatest.Reporter%2Corg.scalatest.Stopper%2CSet%5BString%5D%2CSet%5BString%5D%2CMap%5BString%2CAny%5D%2COption%5Borg.scalatest.Distributor%5D%29"></a><dl>
      <dt>
        
        <code>protected</code>
        <code>def</code>
        <em>runNestedSuites</em>(<em>reporter</em> : <a href="../../org/scalatest/Reporter.html" target="_self">Reporter</a>, <em>stopper</em> : <a href="../../org/scalatest/Stopper.html" target="_self">Stopper</a>, <em>groupsToInclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>groupsToExclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>goodies</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Map">scala.collection.immutable.Map</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>, <a href="http://www.scala-lang.org/docu/files/api/scala/Any.html" target="_self">Any</a>], <em>distributor</em> : <a href="" target="contentFrame" class="scala/Option">scala.Option</a>[<a href="../../org/scalatest/Distributor.html" target="_self">Distributor</a>]) : <a href="http://www.scala-lang.org/docu/files/api/scala/Unit.html" target="_self">Unit</a>
      </dt>
      <dd></dd>
    </dl>
      <dl><dd><p>
   Execute zero to many of this <code>Suite</code>'s nested <code>Suite</code>s.
   </p>
  
   <p>
   If the passed <code>distributor</code> is <code>None</code>, this trait's
   implementation of this method invokes <code>execute</code> on each
   nested <code>Suite</code> in the <code>List</code> obtained by invoking <code>nestedSuites</code>.
   If a nested <code>Suite</code>'s <code>execute</code>
   method completes abruptly with an exception, this trait's implementation of this
   method reports that the <code>Suite</code> aborted and attempts to execute the
   next nested <code>Suite</code>.
   If the passed <code>distributor</code> is <code>Some</code>, this trait's implementation
   puts each nested <code>Suite</code> 
   into the <code>Distributor</code> contained in the <code>Some</code>, in the order in which the
   <code>Suite</code>s appear in the <code>List</code> returned by <code>nestedSuites</code>.
   </p></dd></dl>
      <dl><dt style="margin:10px 0 0 20px;">
        <b>Parameters</b></dt><dd><code>reporter - </code>the <code>Reporter</code> to which results will be reported</dd><dt style="margin:10px 0 0 20px;">
        <b>Throws</b></dt><dd><code>NullPointerException - </code>if <CODE>reporter</CODE> is <CODE>null</CODE>.</dd></dl>
    <hr></hr>
<a name="suiteName"></a><dl>
      <dt>
        
        <code></code>
        <code>def</code>
        <em>suiteName</em> : <a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>
      </dt>
      <dd></dd>
    </dl>
      <dl><dd>A user-friendly suite name for this <code>Suite</code>. This trait's
   implementation of this method returns the simple name of this object's class. This
   trait's implementation of <code>runNestedSuites</code> calls this method to obtain a
   name for <code>Report</code>s to pass to the <code>suiteStarting</code>, <code>suiteCompleted</code>,
   and <code>suiteAborted</code> methods of the <code>Reporter</code>.</dd></dl>
      <dl><dt style="margin:10px 0 0 20px;">
        <b>Returns</b></dt><dd>this <code>Suite</code> object's suite name.</dd></dl>
    <hr></hr>
<a name="expectedTestCount%28Set%5BString%5D%2CSet%5BString%5D%29"></a><dl>
      <dt>
        
        <code></code>
        <code>def</code>
        <em>expectedTestCount</em>(<em>groupsToInclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>], <em>groupsToExclude</em> : <a href="" target="contentFrame" class="scala/collection/immutable/Set">scala.collection.immutable.Set</a>[<a href="" target="contentFrame" class="java/lang/String">java.lang.String</a>]) : <a href="http://www.scala-lang.org/docu/files/api/scala/Int.html" target="_self">Int</a>
      </dt>
      <dd></dd>
    </dl>
      <dl><dd>The total number of tests that are expected to run when this <code>Suite</code>'s <code>execute</code> method is invoked.
   This trait's implementation of this method returns the sum of:
  
   <ul>
   <li>the size of the <code>testNames</code> <code>List</code>
   <li>the sum of the values obtained by invoking
       <code>expecteTestCount</code> on every nested <code>Suite</code> contained in
       <code>nestedSuites</code>
   </ul></dd></dl>
      <dl></dl>
    <hr></hr></div>


    <hr></hr>
        <div>Copyright (C) 2001-2008 Artima, Inc. All rights reserved.</div><table summary="" class="navigation">
        <tr>
          <td class="navigation-links" valign="top">
            <!-- <table><tr></tr></table> -->
          </td>
          <td align="right" valign="top" style="white-space:nowrap;" rowspan="2">
            <div class="doctitle-larger">ScalaTest 0.9.4</div>
          </td>
        </tr>
        <tr><td></td></tr>
      </table>
      </body>
      </html>